{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "code_folding": [],
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 打印所有单行变量\n",
    "from IPython.core.interactiveshell import InteractiveShell\n",
    "InteractiveShell.ast_node_interactivity = 'all'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字符串\n",
    "在python中字符串用单引号`''`或双引号`\"\"`，本身不能修改\n",
    "\n",
    "### 字符串基本操作\n",
    "字符串是一种序列，所有序列都有如下基本操作，这是序列共有的操作。\n",
    "\n",
    "|       |           实例           |     结果      |               描述               |\n",
    "| :---: | :----------------------: | :-----------: | :------------------------------: |\n",
    "| len() |        len('abc')        |       3       |            求序列长度            |\n",
    "|  `+`  |         'a'+'1'          |      a1       |  连接2个序列，必须是同类型数据   |\n",
    "|  `*`  |          'a'*3           |     'aaa'     |           重复序列元素           |\n",
    "|  in   | 'a'in'abc'<br>'d'in'abc' | True<br>False |     判断元素是否存在于序列中     |\n",
    "| max() |        max('abc')        |      'c'      | 返回最大值，大小排序符合字符编码 |\n",
    "| min() |        min('abc')        |      'a'      | 返回最小值，大小排序符合字符编码 |\n",
    "\n",
    ">用比较运算符比较大小\n",
    "\n",
    "### 索引和切片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "code_folding": [],
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'s'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lang = \"study python\"\n",
    "\n",
    "lang[0]  # -->\n",
    "lang[1]  # -->\n",
    "\"study python\"[0]  # -->\n",
    "lang.index(\"p\")    # -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |  11   |\n",
    "| :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: |\n",
    "|   s   |   t   |   u   |   d   |   y   |       |   p   |   y   |   t   |   h   |   o   |   n   |\n",
    "|  -12  |  -11  |  -10  |  -9   |  -8   |  -7   |  -6   |  -5   |  -4   |  -3   |  -2   |  -1   |\n",
    "\n",
    ">第一个不是用数字1表示，而是用数字0表示\n",
    "\n",
    "|        切片         |      结果      |                                   描述                                    |\n",
    "| :-----------------: | :------------: | :-----------------------------------------------------------------------: |\n",
    "| str[start:end:step] |  默认正向切片  | 切片取值：前包括后不包括<br>step为空时，缺省值为1<br>step<0时，则反向切片 |\n",
    "|      lang[1:]       | 'tudy python'  |               得到从1号到最末尾的字符,此时最后那个可以不写                |\n",
    "|       lang[:]       | 'study python' |                               得到所有字符                                |\n",
    "|      lang[:10]      |  'study pyth'  |                       得到从第一个到10号之前的字符                        |\n",
    "|     lang[1:4:2]     |      'td'      |                         得到以step=2从1到4的字符                          |\n",
    "|     lang[::-1]      | 'nohtyp yduts' |                             反向得到所有字符                              |\n",
    "\n",
    "### Python转义字符\n",
    "在字符串中，总会有一些特殊的符号，就需要用转义符。所谓转义，就是不采用符号本来的含义，而采用另外一含义。下面表格中列出常用的转义符：\n",
    "\n",
    "| 转义字符 |                     描述                     |\n",
    "| -------- | -------------------------------------------- |\n",
    "| `\\`      | (在行尾时) 续行符                            |\n",
    "| `\\\\`     | 反斜杠符号                                   |\n",
    "| `\\'`     | 单引号                                       |\n",
    "| `\\\"`     | 双引号                                       |\n",
    "| \\a       | 响铃                                         |\n",
    "| \\b       | 退格(Backspace)                              |\n",
    "| \\e       | 转义                                         |\n",
    "| \\000     | 空                                           |\n",
    "| \\n       | 换行                                         |\n",
    "| \\v       | 纵向制表符                                   |\n",
    "| \\t       | 横向制表符                                   |\n",
    "| \\r       | 回车                                         |\n",
    "| \\f       | 换页                                         |\n",
    "| \\oyy     | 八进制数，yy代表的字符，例如：\\o12代表换行   |\n",
    "| \\xyy     | 十六进制数，yy代表的字符，例如：\\x0a代表换行 |\n",
    "| \\other   | 其它的字符以普通格式输出                     |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 常用的字符串方法\n",
    "> dir(str)列出字符的属性和方法  \n",
    "> hlep(str)查看帮助"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['capitalize',\n",
       " 'casefold',\n",
       " 'center',\n",
       " 'count',\n",
       " 'encode',\n",
       " 'endswith',\n",
       " 'expandtabs',\n",
       " 'find',\n",
       " 'format',\n",
       " 'format_map',\n",
       " 'index',\n",
       " 'isalnum',\n",
       " 'isalpha',\n",
       " 'isdecimal',\n",
       " 'isdigit',\n",
       " 'isidentifier',\n",
       " 'islower',\n",
       " 'isnumeric',\n",
       " 'isprintable',\n",
       " 'isspace',\n",
       " 'istitle',\n",
       " 'isupper',\n",
       " 'join',\n",
       " 'ljust',\n",
       " 'lower',\n",
       " 'lstrip',\n",
       " 'maketrans',\n",
       " 'partition',\n",
       " 'replace',\n",
       " 'rfind',\n",
       " 'rindex',\n",
       " 'rjust',\n",
       " 'rpartition',\n",
       " 'rsplit',\n",
       " 'rstrip',\n",
       " 'split',\n",
       " 'splitlines',\n",
       " 'startswith',\n",
       " 'strip',\n",
       " 'swapcase',\n",
       " 'title',\n",
       " 'translate',\n",
       " 'upper',\n",
       " 'zfill']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for i in dir('') if not i.startswith('_')]  # 列表解析式，这里不打印已__开头的特殊属性方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function startswith:\n",
      "\n",
      "startswith(...) method of builtins.str instance\n",
      "    S.startswith(prefix[, start[, end]]) -> bool\n",
      "    \n",
      "    Return True if S starts with the specified prefix, False otherwise.\n",
      "    With optional start, test S beginning at that position.\n",
      "    With optional end, stop comparing S at that position.\n",
      "    prefix can also be a tuple of strings to try.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(''.startswith)    # 查看具体方法，startswith这里是没有括号的，带括号是调用该方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### capitalize()\n",
    "将字符串的第一个字符改为大写"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Abc'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc'.capitalize()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### casefold()\n",
    "将整个字符串的所有字符改为小写,可用处理unicode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ABc'.casefold()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### center(width[, fillchar])\n",
    "返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'*abc*'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc'.center(5, '*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### count(sub[, start[, end]])\n",
    "返回 sub 在字符串里边出现的次数，start 和 end 参数表示范围，可选。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'aabc'.count('a')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### find(sub[, start[, end]])\n",
    "检测 sub 是否包含在字符串中，如果有则返回索引值，否则返回 -1，start 和 end 参数表示范围。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc'.find('c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### join(sub)\n",
    "以字符串作为分隔符，插入到 sub 中所有的字符之间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a-b-c'"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'-'.join(['a','b','c'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### lower()\n",
    "转换字符串中所有大写字符为小写。只对 ASCII 也就是 'A-Z'有效"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'ABC'.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### upper()\n",
    "转换字符串中的所有小写字符为大写。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABC'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc'.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### strip([chars])\n",
    "删除字符串前边和后边所有的空白占位符(包括\\n\\t等)，chars 参数可以定制删除的字符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a bc'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'  a bc\\t'.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### replace(old, new[, count])\n",
    "把字符串中的 old 子字符串替换成 new 子字符串，如果 count 指定，则替换不超过 count 次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aaddbc'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'aabbbc'.replace('b', 'd', 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 字符串格式化输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I like python and music'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I like %s and %s\" % (\"python\",'music') # 从左至右一一对应"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 格式化符号 |                 描述                 |\n",
    "| :--------: | :----------------------------------- |\n",
    "|     %c     | 格式化字符及其ASCII码                |\n",
    "|     %s     | 格式化字符串                         |\n",
    "|     %d     | 格式化整数                           |\n",
    "|     %u     | 格式化无符号整型                     |\n",
    "|     %o     | 格式化无符号八进制数                 |\n",
    "|     %x     | 格式化无符号十六进制数               |\n",
    "|     %X     | 格式化无符号十六进制数（大写）       |\n",
    "|     %f     | 格式化浮点数字，可指定小数点后的精度 |\n",
    "|     %e     | 用科学计数法格式化浮点数             |\n",
    "|     %E     | 作用同%e，用科学计数法格式化浮点数   |\n",
    "|     %p     | 用十六进制数格式化变量的地址         |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### format()方法\n",
    "##### 匿名参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I like python and markdown'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I like {} and {}\".format(\"python\", \"markdown\")  # 默认从0开始"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I like markdown and python'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I like {1} and {0}\".format(\"python\", \"markdown\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 命名参数，参数可重用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'姓名：wanli, 年龄：26, 虚岁：26'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'姓名：{name}, 年龄：{age}, 虚岁：{age}'.format(name='wanli', age=26)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 填充和对齐\n",
    "既然是“格式化”，就要指定一些格式，让输出的结果符合指定的样式。  \n",
    "填充常跟对齐一起使用`^` `<` `>`分别是居中、左对齐、右对齐，后面带宽度  \n",
    "`:`后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 传入字符串(默认左对齐)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I like python     and        markdown'"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I like {0:10} and {1:>15}\".format(\"python\", \"markdown\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I like python     and    markdown    '"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I like {0:<10} and {1:^15}\".format(\"python\", \"markdown\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I like py and ***mark***'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"I like {0:.2} and {1:*^10.4}\".format(\"python\", \"markdown\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `{0:10}` `{0:<10}`：表示第一个位置，占10个字符长度，并且该位置字符左对齐，字符串默认是左对齐  \n",
    "* `{1:>15}`：表示第二个位置，占15个字符长度，并且该位置字符右对齐。  \n",
    "* `{1:^15}`：表示第二个位置，占15个字符长度，并且该位置字符居中对齐。  \n",
    "* `{0:.2}`：在`:` `.`之间，没有任何数字，表示自适应放入字符，`.2`表示对于传入的字符串，截取前两个。  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "##### 传入数字(默认右对齐)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'π=     3.142'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"π={:10.4}\".format(3.14159265358979)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'π=    3.1416'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"π={:10.4f}\".format(3.14159265358979)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'π=00003.1416'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"π={:010.4f}\".format(3.14159265358979)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'π=00003.1416'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"π={:0>10.4f}\".format(3.14159265358979)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`{:10.4f}`：`.4f`表示传入的是float类型，且保留4位小数\n",
    "\n",
    "因为传入的是数字默认右对齐，所以`{:010.4f}`和`{:0>10.4f}`结果一样，但是`{:010.4f}`很容易看懵逼"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 根据分隔符分割字符串\n",
    "`split()`的作用是将字符串根据某个分割符进行分割，返回的是一个列表。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['I', 'LOVE', 'PYTHON']"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"I      LOVE PYTHON\"\n",
    "a.split()  # 不带参数时默认是空白占位符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['www', 'baidu', 'com']"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = \"www.baidu.com\"\n",
    "b.split(\".\")  # 以‘.’分割"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### join()拼接字符串\n",
    "\n",
    "`'sep'.join(seq)`：以sep作为分隔符，将seq所有的元素合并成一个新的字符串"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['www', 'baidu', 'com']"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 'www.baidu.com'\n",
    "c = b.split(\".\")\n",
    "\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'www.baidu.com'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": [
       "'www*baidu*com'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\".\".join(c)\n",
    "\"*\".join(c)"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4rc1"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {
    "height": "839px",
    "left": "0px",
    "right": "1591px",
    "top": "107px",
    "width": "329px"
   },
   "toc_section_display": "block",
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": "15",
    "lenType": "10",
    "lenVar": "60"
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
